/************************************************************************/
/*  rx_search_test.c                                                    */
/*  GNU Regex 测试                                                      */
/*  rx_search 实现调用regexe多次搜索字符串中满足正则表达式的匹配,       */
/*  并保存到 search_match_t                                             */
/*  author guyadong                                                     */
/************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <regex.h>
#include <limits.h>
#include <string.h>

/** regex 错误输出缓冲区 */
static char regerrbuf[256];

/** 输出字符串中指定范围的字符到控制台 */
void print_str(const char* input, size_t _start, size_t _end)
{
	if (input)
	{
		for (size_t i = _start; i < _end; ++i)
		{
			printf("%c", input[i]);
		}
	}
}

/************************************************************************/
/* 保存执行 regexec 多次匹配数据                                          */
/************************************************************************/
typedef struct search_match_t
{
	/** 捕获组数量(包含group 0) */
	size_t groupcnt;
	/** 可保存匹配次数 */
	size_t capacity;
	/** 匹配次数 */
	size_t matchcnt;
	/************************************************************************/
	/* 以在字符串中的顺序保存每一次匹配的数据,                              */
	/* 数组长度为 capacity*groupcnt,                                        */
	/* rx_search在执行时会根据需要自动对数组长度扩容                        */
	/************************************************************************/
	regmatch_t* pmatch;
}search_match_t;

//************************************
// search_match_t 初始化,以初始容量16分配内存,并将内存清零
// 如果匹配次数超过容量,会调用 rx_search_match_ensure 自动扩容
// @param    search_match_t * _psmatch
// @param    size_t           groupcnt
// @return   int              成功返回0,否则返回-1
//************************************
static int rx_search_match_init(search_match_t* _psmatch,size_t groupcnt)
{
	if(NULL == _psmatch){
		return -1;
	}
	_psmatch->capacity = 16;
	_psmatch->matchcnt = 0;
	_psmatch->groupcnt = groupcnt;
	size_t size = sizeof(regmatch_t) * groupcnt * _psmatch->capacity;
	_psmatch->pmatch = (regmatch_t*)malloc(size);	
	if(!_psmatch->pmatch)
	{
		printf("%s:%d MEM ERROR\n",__FILE__,__LINE__);
		return -1;
	}
	/** 内存清零 */
	memset(_psmatch->pmatch, 0, size);
	return 0;
}
//************************************
// search_match_t 扩容,确保 search_match_t 中有足够的空闲空间保存 freecnt 指定大小的匹配数据
// 扩容部分内存清零
// @param    search_match_t * _psmatch
// @param    size_t           freecnt 要求空闲保存的匹配空间数量(每个匹配需要的regmatch_t数量为groupcnt)
// @return   regmatch_t*      扩容成功返回最后空闲的regmatch_t起始位置,否则返回NULL
//************************************
static regmatch_t* rx_search_match_ensure(search_match_t * _psmatch, size_t freecnt)
{
	regmatch_t *newbuffer = NULL;
	size_t newsize = 0;
	size_t newcapacity = 0;

	if ((_psmatch == NULL) || (_psmatch->pmatch == NULL))
	{
		printf("%s:%d NULL ARGUMENT\n",__FILE__,__LINE__);
		return NULL;
	}

	if ((_psmatch->capacity > 0) && (_psmatch->matchcnt > _psmatch->capacity))
	{
		printf("%s:%d INVALID matchcnt %d\n",__FILE__,__LINE__,(int)_psmatch->matchcnt);
		return NULL;
	}

	if (freecnt > (INT_MAX / 64))
	{
		printf("%s:%d TOO LARGE ARGUMENT matchcnt %d\n",__FILE__,__LINE__,(int)freecnt);
		return NULL;
	}

	if (freecnt <= (_psmatch->capacity - _psmatch->matchcnt))
	{
		return _psmatch->pmatch + (_psmatch->matchcnt * _psmatch->groupcnt);
	}

	/** 以16整数倍扩容 */
	newcapacity = ((freecnt + _psmatch->matchcnt + 16 - 1) >> 4 << 4);
	newsize = newcapacity * _psmatch->groupcnt * sizeof(regmatch_t);

	/* reallocate with realloc if available */
	newbuffer = (regmatch_t*)realloc(_psmatch->pmatch, newsize);
	if (newbuffer == NULL)
	{
		printf("%s:%d MEM ERROR\n",__FILE__,__LINE__);
		free(_psmatch->pmatch);
		_psmatch->capacity = 0;
		_psmatch->groupcnt = 0;
		_psmatch->matchcnt = 0;
		_psmatch->pmatch = NULL;

		return NULL;
	}
	size_t oldsize =                _psmatch->matchcnt  * _psmatch->groupcnt * sizeof(regmatch_t);
	size_t expsize = (newcapacity - _psmatch->matchcnt) * _psmatch->groupcnt * sizeof(regmatch_t);
	/** 扩容部分清零 */
	memset((char*)newbuffer + oldsize, 0, expsize);

	_psmatch->capacity = newcapacity;
	_psmatch->pmatch = newbuffer;
	printf("%s:%d pmatch buffer expand to %d match\n",__FILE__,__LINE__, (int)newcapacity);
	return _psmatch->pmatch + (_psmatch->matchcnt * _psmatch->groupcnt);
}
//************************************
// 释放search_match_t中分配的空间,
// @param    search_match_t * _psmatch
//************************************
void rx_search_match_uninit(search_match_t* _psmatch)
{
	if (_psmatch)
	{
		free(_psmatch->pmatch);
		memset(_psmatch, 0, sizeof(search_match_t));
	}
}
//************************************
// 用指定的正则表达式在字符串中查找所有匹配
// @param    const char * input    待匹配的字符串
// @param    const char * pattern  正则表达式
// @param    size_t       groupcnt 正则表达式中捕获组数量(包含默认组group 0),为0时使用默认值,即pattern编译后regex_t的re_nsub+1
//                                 regex_t.re_nsub字段为正则表达式中子表达式的数量,子表达式又分为捕获和非捕获两种.
//                                 所以re_nsub + 1肯定大于等于表达式中所有捕获组(包含默认组group 0)的数量
// @param    int          eflags   正则表达匹配执行标志,参见 regexec
// @param    search_match_t *      _psmatch [out] 保存字符串所有匹配的位置
// @return   int                   匹配成功返回匹配匹配的数量,没有匹配返回0,失败返回-1,
//                                 调用层必须调用rx_search_match_uninit释放分配的空间
//************************************
int rx_serach(const char* input, const char* pattern, size_t groupcnt, int eflags, search_match_t* _psmatch)
{
	if (NULL == input || NULL == pattern || NULL == _psmatch)
	{
		printf("%s:%d NULL ARGUMENT\n",__FILE__,__LINE__);
		return 0;
	}
	/** 对 _psmatch 对象内存清零,确保不论是否regcomp匹配成功,rx_search_match_uninit都能正确执行 */
	memset(_psmatch, 0, sizeof(search_match_t));
	regex_t reg;
	/************************************************************************/
	/* 编译正则表达式,编译成功的 regex_t 对象才可以被后续的 regexec 使用    */
	/************************************************************************/
	int c = regcomp(&reg, pattern, REG_EXTENDED);
	if (0 != c)
	{
		/************************************************************************/
		/*  正则表达式编译出错输出错误信息                                      */
		/*  调用 regerror 将错误信息输出到 regerrbuf 中                         */
		/*  regerrbuf 末尾置0,确保上面调用regerror 导致 regerrbuf 溢出的情况下, */
		/*  字符串仍有有结尾0                                                   */
		/*  然后 printf 输出                                                    */
		/************************************************************************/
		regerror(c, &reg, regerrbuf, sizeof(regerrbuf));
		regerrbuf[sizeof(regerrbuf) - 1] = '\0';
		printf("%s:%d %s\n",__FILE__,__LINE__, regerrbuf);
		return -1;
	}
	
	if (0 == groupcnt)
	{
		groupcnt = reg.re_nsub + 1;
	}
	c = rx_search_match_init(_psmatch, groupcnt);
	if (0 != c)
	{
		/** search_match_t 初始化失败,释放前面初始化成功的 regex_t */
		regfree(&reg);
		return c;
	}
	/** 起始匹配的偏移量 */
	size_t offset = 0;
	/************************************************************************/
	/* regexec 不能通过一次调用找到字符串中所有满足匹配条件的字符串位置,    */
	/* 所以需要通过步进偏移的方式循环查找字符串中所有匹配的字符串,          */
	/* 每一次匹配的起始偏移是上一次匹配到的字符串结束偏移                   */
	/************************************************************************/
	do {
		printf("MATCH start %d\n", (int)offset);
		/** 输出缓冲区扩容 */
		regmatch_t* pmatch = rx_search_match_ensure(_psmatch, 1);
		if (NULL == pmatch)
		{
			printf("%s:%d MEMORY ERROR for rx_search_match_ensure\n",__FILE__,__LINE__);
			c = -1;
			break;
		}
		/** 正则表达式匹配的起始地址 */
		const char* p = input + offset;
		/************************************************************************/
		/* regmatch_t 用于记录正则表达匹配的结果,每一个 regmatch_t 记录一个捕获 */
		/* 组(catch group)的在字符串中的起始位置。                              */
		/* 如果调用 regexec 时如果不提供 regmatch_t(nmatch为0,pmatch为NULL),    */
		/* 或者提供的 regmatch_t 数组长小于正则表达式中全部捕获组的数量,        */
		/* regexec 也能正常匹配,只是无法记录匹配的位置                          */
		/* 或不能完全记录所有的匹配结果                                         */
		/************************************************************************/
		c = regexec(&reg, p, _psmatch->groupcnt, pmatch, eflags);
		if (REG_NOMATCH == c)
		{
			/************************************************************************/
			/** 没有找到匹配结束循环                                                */
			/************************************************************************/
			printf("MATCH FINISHED\n");
			break;
		}
		else if (0 == c)
		{
			/** 匹配计数加1 */
			_psmatch->matchcnt++;
			/** 找到匹配,则输出匹配到的所有捕获组(catch group) */
			printf("%d MATCH (%d-%d)\n", (int)_psmatch->matchcnt, pmatch[0].rm_so, pmatch[0].rm_eo);
			for (int i = 0; i < _psmatch->groupcnt; ++i)
			{
				printf("group %d :<<", i);
				print_str(p, pmatch[i].rm_so, pmatch[i].rm_eo);
				printf(">>\n");
			}
			/** (group 0)的结束位置 */
			size_t eo = pmatch[0].rm_eo;
			for (int i = 0; i < _psmatch->groupcnt; ++i)
			{
				/** 偏移量修改为相对于字符串起始位置 */
				pmatch[i].rm_so += (int)offset;
				pmatch[i].rm_eo += (int)offset;
			}
			/************************************************************************/
			/* 使用整体匹配捕获组0(group 0)的结束位置的更新偏移量,                  */
			/* 下一次匹配从当前匹配的结束位置开始                                   */
			/************************************************************************/
			offset += eo;
			continue;
		}
		else
		{
			/************************************************************************/
			/** regexec 调用出错输出错误信息,结束循环                               */
			/************************************************************************/
			regerror(c, &reg, regerrbuf, sizeof(regerrbuf));
			regerrbuf[sizeof(regerrbuf) - 1] = '\0';
			printf("%s\n", regerrbuf);
			c = -1;
			break;
		}
	} while (1);
	printf("%d MATCH FOUND\n", (int)_psmatch->matchcnt);
	/************************************************************************/
	/** regfree 必须与 regcomp 配对使用,否则会发生内存泄露                  */
	/************************************************************************/
	regfree(&reg);
	/** REG_NOMATCH 为正常循环结束标志  */
	if (c != REG_NOMATCH)
	{
		/** 出错时释放 search_match_t 所占内存 */
		rx_search_match_uninit(_psmatch);
		return c;
	}
	return (int)_psmatch->matchcnt;

}

int main() {

	/** 待匹配字符串 */
	const char* inputstr = "hello,welcome to my party welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome welcome ";
	regex_t reg;
	/** 正则表达式 */
	const char* pattern = "(we|par)([a-z]+)";
	printf("==rx_serach Test==\n");
	printf("Pattern     :%s\n", pattern);
	printf("Input String:%s\n", inputstr);
	search_match_t _smatch;
	int c = rx_serach(inputstr,pattern, 0, 0, &_smatch);	
	if(c > 0)
	{
		/* 输出 search_match_t 中记录的所有匹配结果 */
		printf("====MATCH RESULT====\n");
		size_t off = 0;
		for (int i = 0; i < c; ++i,off += _smatch.groupcnt)
		{
			printf("MATCH %d\n", i);
			regmatch_t* gm = _smatch.pmatch + off ;
			for (int g = 0; g < _smatch.groupcnt; ++g)
			{
				printf("\tgroup %d <<", g);
				print_str(inputstr, gm[g].rm_so, gm[g].rm_eo);
				printf(">>\n");

			}			
		}
	}
	/************************************************************************/
	/* 调用 rx_serach 之后必须调用 rx_search_match_uninit 释放分配的内存    */
	/* 否则会产生内存泄露                                                   */
	/************************************************************************/
	rx_search_match_uninit(&_smatch);
	return 0;

}
